/**
 * 本地存储工具类
 * 提供对localStorage的封装，支持数据持久化存储
 */
import { localStorageKeys } from './localStorageKeys';

export class LocalStorage {
  /**
   * 获取存储项
   * @param {string} key - 存储键名
   * @returns {string | null} 存储的值，如果不存在则返回null
   */
  static getItem(key: string) {
    try {
      return localStorage.getItem(key);
    } catch (error) {
      console.warn(`获取本地存储失败 [${key}]:`, error);
      return null;
    }
  }

  /**
   * 设置存储项
   * @param {string} key - 存储键名
   * @param {string} value - 要存储的值
   * @returns {boolean} 操作是否成功
   */
  static setItem(key: string, value: string) {
    try {
      localStorage.setItem(key, value);
      return true;
    } catch (error) {
      console.warn(`设置本地存储失败 [${key}]:`, error);
      return false;
    }
  }

  /**
   * 删除存储项
   * @param {string} key - 存储键名
   * @returns {boolean} 操作是否成功
   */
  static removeItem(key: string) {
    try {
      localStorage.removeItem(key);
      return true;
    } catch (error) {
      console.warn(`删除本地存储失败 [${key}]:`, error);
      return false;
    }
  }

  /**
   * 清空所有存储
   * @returns {boolean} 操作是否成功
   */
  static clear() {
    try {
      localStorage.clear();
      return true;
    } catch (error) {
      console.warn('清空本地存储失败:', error);
      return false;
    }
  }

  /**
   * 获取带类型的存储项（自动JSON解析）
   * @param {string} key - 存储键名
   * @param {*} defaultValue - 默认值
   * @returns {*} 解析后的值或默认值
   */
  static getTypedItem(key: string, defaultValue = null) {
    const item = this.getItem(key);
    if (item === null) {
      return defaultValue;
    }

    try {
      return JSON.parse(item);
    } catch (error) {
      console.warn(`解析本地存储数据失败 [${key}]:`, error);
      return defaultValue;
    }
  }

  /**
   * 设置带类型的存储项（自动JSON序列化）
   * @param {string} key - 存储键名
   * @param {*} value - 要存储的值
   * @returns {boolean} 操作是否成功
   */
  static setTypedItem(key: string, value: any) {
    try {
      return this.setItem(key, JSON.stringify(value));
    } catch (error) {
      console.warn(`序列化并存储数据失败 [${key}]:`, error);
      return false;
    }
  }

  /**
   * 获取所有本地存储键名
   * @returns {string[]} 键名数组
   */
  static getAllKeys(): string[] {
    try {
      const keys = [];
      for (let i = 0; i < localStorage.length; i++) {
        const key = localStorage.key(i);
        if (key) {
          keys.push(key);
        }
      }
      return keys;
    } catch (error) {
      console.warn('获取所有键名失败:', error);
      return [];
    }
  }

  /**
   * 检查存储空间使用情况
   * @returns {{used: number, available: number}} 使用情况估算
   */
  static getStorageInfo(): { used: number; available: number } {
    try {
      let used = 0;
      for (let i = 0; i < localStorage.length; i++) {
        const key = localStorage.key(i);
        if (key) {
          const value = localStorage.getItem(key);
          if (value) {
            used += key.length + value.length;
          }
        }
      }

      // 估算可用空间（通常5MB）
      const available = 5 * 1024 * 1024 - used;

      return { used, available };
    } catch (error) {
      console.warn('获取存储信息失败:', error);
      return { used: 0, available: 0 };
    }
  }

  /**
   * 获取本地存储键的描述信息
   * @param {string} key - 存储键名
   * @returns {string} 键的描述信息，如果不存在则返回空字符串
   */
  static getKeyDescription(key: string): string {
    return (localStorageKeys as Record<string, string>)[key] || '';
  }
}
